
#ifndef RStringBuilder_h
#define RStringBuilder_h

#include <System/Object.h>
#include <System/String.h>
#include <System/ArgumentOutOfRangeException.h>
#include <System/Collections/Generic/List.h>

namespace Riccsson
{
	namespace System
	{
		namespace Text
		{
			// Summary:
			//     Represents a mutable string of characters. This class cannot be inherited.
			//[Serializable]
			//[ComVisible(true)]
			class StringBuilder sealed //: ISerializable
			{
				private: int _length;
				private: Collections::Generic::List<char**> _string;
						 
				//----------------------------------------------------------------------------
				private: void init(string* value_in, int startIndex, int length, int capacity, int maxCapacity)
                {
					string value = *value_in;

                    if (null == value_in)
						value = "";

                    if (startIndex < 0)
						throw ArgumentOutOfRangeException("startIndex", startIndex, "StartIndex cannot be less than zero.");

                    if(length < 0)
						throw ArgumentOutOfRangeException("length", length, "Length cannot be less than zero.");


                    if (capacity < 0)
						throw ArgumentOutOfRangeException("capacity", capacity, "capacity must be greater than zero.");

                    if (maxCapacity < 1)
						throw ArgumentOutOfRangeException("maxCapacity", "maxCapacity is less than one.");
                    if (capacity > maxCapacity)
						throw ArgumentOutOfRangeException("capacity", "Capacity exceeds maximum capacity.");

                    if (startIndex > value.Length - length)
						throw ArgumentOutOfRangeException("startIndex", startIndex, "StartIndex and length must refer to a location within the string.");

					throw;
                }


				// Summary:
				//     Initializes a new instance of the System.Text.StringBuilder class.
				//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
				public: StringBuilder()
				{
					throw;
				}

				//
				// Summary:
				//     Initializes a new instance of the System.Text.StringBuilder class using the
				//     specified capacity.
				//
				// Parameters:
				//   capacity:
				//     The suggested starting size of this instance.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     capacity is less than zero.
				//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
				public: StringBuilder(int capacity)
				{
					throw;
				}

				//
				// Summary:
				//     Initializes a new instance of the System.Text.StringBuilder class using the
				//     specified string.
				//
				// Parameters:
				//   value:
				//     The string used to initialize the value of the instance. If value is null,
				//     the new System.Text.StringBuilder will contain the empty string (that is,
				//     it contains System.String.Empty).
				public: StringBuilder(Riccsson::System::string* value)
				{
					throw;
				}

				//
				// Summary:
				//     Initializes a new instance of the System.Text.StringBuilder class that starts
				//     with a specified capacity and can grow to a specified maximum.
				//
				// Parameters:
				//   capacity:
				//     The suggested starting size of the System.Text.StringBuilder.
				//
				//   maxCapacity:
				//     The maximum number of characters the current string can contain.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     maxCapacity is less than one, capacity is less than zero, or capacity is
				//     greater than maxCapacity.
				public: StringBuilder(int capacity, int maxCapacity)
				{
					throw;
				}

				//
				// Summary:
				//     Initializes a new instance of the System.Text.StringBuilder class using the
				//     specified string and capacity.
				//
				// Parameters:
				//   value:
				//     The string used to initialize the value of the instance. If value is null,
				//     the new System.Text.StringBuilder will contain the empty string (that is,
				//     it contains System.String.Empty).
				//
				//   capacity:
				//     The suggested starting size of the System.Text.StringBuilder.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     capacity is less than zero.
				//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
				public: StringBuilder(Riccsson::System::string* value, int capacity)
				{
					throw;
				}

				//
				// Summary:
				//     Initializes a new instance of the System.Text.StringBuilder class from the
				//     specified substring and capacity.
				//
				// Parameters:
				//   value:
				//     The string that contains the substring used to initialize the value of this
				//     instance. If value is null, the new System.Text.StringBuilder will contain
				//     the empty string (that is, it contains System.String.Empty).
				//
				//   startIndex:
				//     The position within value where the substring begins.
				//
				//   length:
				//     The number of characters in the substring.
				//
				//   capacity:
				//     The suggested starting size of the System.Text.StringBuilder.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     capacity is less than zero.-or- startIndex plus length is not a position
				//     within value.
				//[SecuritySafeCritical]
				public: StringBuilder(Riccsson::System::string* value, int startIndex, int length, int capacity)
				{
					throw;
				}


				// Summary:
				//     Gets or sets the maximum number of characters that can be contained in the
				//     memory allocated by the current instance.
				//
				// Returns:
				//     The maximum number of characters that can be contained in the memory allocated
				//     by the current instance.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     The value specified for a set operation is less than the current length of
				//     this instance.-or- The value specified for a set operation is greater than
				//     the maximum capacity.
				//public: int Capacity { get; set; }

				//
				// Summary:
				//     Gets or sets the length of the current System.Text.StringBuilder object.
				//
				// Returns:
				//     The length of this instance.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     The value specified for a set operation is less than zero or greater than
				//     System.Text.StringBuilder.MaxCapacity.
				//public: int Length { get; set; }

				//
				// Summary:
				//     Gets the maximum capacity of this instance.
				//
				// Returns:
				//     The maximum number of characters this instance can hold.
				//public: int MaxCapacity { get; }

				// Summary:
				//     Gets or sets the character at the specified character position in this instance.
				//
				// Parameters:
				//   index:
				//     The position of the character.
				//
				// Returns:
				//     The Unicode character at position index.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     index is outside the bounds of this instance while setting a character.
				//
				//   System.IndexOutOfRangeException:
				//     index is outside the bounds of this instance while getting a character.
				public: char operator[](int index)// { get; set; }
				{
					throw;
				}

				// Summary:
				//     Appends the string representation of a specified Boolean value to this instance.
				//
				// Parameters:
				//   value:
				//     The Boolean value to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Append(bool value)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string representation of a specified 8-bit unsigned integer to
				//     this instance.
				//
				// Parameters:
				//   value:
				//     The value to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Append(byte value)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string representation of a specified Unicode character to this
				//     instance.
				//
				// Parameters:
				//   value:
				//     The Unicode character to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Append(char value)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string representation of the Unicode characters in a specified
				//     array to this instance.
				//
				// Parameters:
				//   value:
				//     The array of characters to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				//[SecuritySafeCritical]
				public: GC_PTR<StringBuilder> Append(Riccsson::System::Array<char>* value)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string representation of a specified decimal number to this instance.
				//
				// Parameters:
				//   value:
				//     The value to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Append(decimal value)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string representation of a specified double-precision floating-point
				//     number to this instance.
				//
				// Parameters:
				//   value:
				//     The value to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Append(double value)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string representation of a specified single-precision floating-point
				//     number to this instance.
				//
				// Parameters:
				//   value:
				//     The value to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Append(float value)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string representation of a specified 32-bit signed integer to
				//     this instance.
				//
				// Parameters:
				//   value:
				//     The value to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
				public: GC_PTR<StringBuilder> Append(int value)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string representation of a specified 64-bit signed integer to
				//     this instance.
				//
				// Parameters:
				//   value:
				//     The value to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Append(long value)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string representation of a specified object to this instance.
				//
				// Parameters:
				//   value:
				//     The object to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
				public: GC_PTR<StringBuilder> Append(Riccsson::System::object* value)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string representation of a specified 8-bit signed integer to
				//     this instance.
				//
				// Parameters:
				//   value:
				//     The value to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				//[CLSCompliant(false)]
				public: GC_PTR<StringBuilder> Append(sbyte value)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string representation of a specified 16-bit signed integer to
				//     this instance.
				//
				// Parameters:
				//   value:
				//     The value to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Append(short value)
				{
					throw;
				}

				//
				// Summary:
				//     Appends a copy of the specified string to this instance.
				//
				// Parameters:
				//   value:
				//     The string to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				//[SecuritySafeCritical]
				public: GC_PTR<StringBuilder> Append(Riccsson::System::string* value)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string representation of a specified 32-bit unsigned integer
				//     to this instance.
				//
				// Parameters:
				//   value:
				//     The value to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				//[CLSCompliant(false)]
				public: GC_PTR<StringBuilder> Append(uint value)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string representation of a specified 64-bit unsigned integer
				//     to this instance.
				//
				// Parameters:
				//   value:
				//     The value to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				//[CLSCompliant(false)]
				public: GC_PTR<StringBuilder> Append(ulong value)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string representation of a specified 16-bit unsigned integer
				//     to this instance.
				//
				// Parameters:
				//   value:
				//     The value to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				//[CLSCompliant(false)]
				public: GC_PTR<StringBuilder> Append(ushort value)
				{
					throw;
				}

				//
				// Summary:
				//     Appends a specified number of copies of the string representation of a Unicode
				//     character to this instance.
				//
				// Parameters:
				//   value:
				//     The character to append.
				//
				//   repeatCount:
				//     The number of times to append value.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     repeatCount is less than zero.-or- Enlarging the value of this instance would
				//     exceed System.Text.StringBuilder.MaxCapacity.
				//
				//   System.OutOfMemoryException:
				//     Out of memory.
				public: GC_PTR<StringBuilder> Append(char value, int repeatCount)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string representation of a specified subarray of Unicode characters
				//     to this instance.
				//
				// Parameters:
				//   value:
				//     A character array.
				//
				//   startIndex:
				//     The starting position in value.
				//
				//   charCount:
				//     The number of characters to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     value is null, and startIndex and charCount are not zero.
				//
				//   System.ArgumentOutOfRangeException:
				//     charCount is less than zero.-or- startIndex is less than zero.-or- startIndex
				//     + charCount is greater than the length of value.-or- Enlarging the value
				//     of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				//[SecuritySafeCritical]
				public: GC_PTR<StringBuilder> Append(Riccsson::System::Array<char>* value, int startIndex, int charCount)
				{
					throw;
				}

				//
				// Summary:
				//     Appends a copy of a specified substring to this instance.
				//
				// Parameters:
				//   value:
				//     The string that contains the substring to append.
				//
				//   startIndex:
				//     The starting position of the substring within value.
				//
				//   count:
				//     The number of characters in value to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     value is null, and startIndex and count are not zero.
				//
				//   System.ArgumentOutOfRangeException:
				//     count less than zero.-or- startIndex less than zero.-or- startIndex + count
				//     is greater than the length of value.-or- Enlarging the value of this instance
				//     would exceed System.Text.StringBuilder.MaxCapacity.
				//[SecuritySafeCritical]
				public: GC_PTR<StringBuilder> Append(Riccsson::System::string* value, int startIndex, int count)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string returned by processing a composite format string, which
				//     contains zero or more format items, to this instance. Each format item is
				//     replaced by the string representation of a single argument.
				//
				// Parameters:
				//   format:
				//     A composite format string (see Remarks).
				//
				//   arg0:
				//     An object to format.
				//
				// Returns:
				//     A reference to this instance with format appended. Each format item in format
				//     is replaced by the string representation of arg0.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     format is null.
				//
				//   System.FormatException:
				//     format is invalid. -or-The index of a format item is less than 0 (zero),
				//     or greater than or equal to 1.
				//
				//   System.ArgumentOutOfRangeException:
				//     The length of the expanded string would exceed System.Text.StringBuilder.MaxCapacity.
				//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
				public: GC_PTR<StringBuilder> AppendFormat(Riccsson::System::string* format, Riccsson::System::object* arg0)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string returned by processing a composite format string, which
				//     contains zero or more format items, to this instance. Each format item is
				//     replaced by the string representation of a corresponding argument in a parameter
				//     array.
				//
				// Parameters:
				//   format:
				//     A composite format string (see Remarks).
				//
				//   args:
				//     An array of objects to format.
				//
				// Returns:
				//     A reference to this instance with format appended. Each format item in format
				//     is replaced by the string representation of the corresponding object argument.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     format or args is null.
				//
				//   System.FormatException:
				//     format is invalid. -or-The index of a format item is less than 0 (zero),
				//     or greater than or equal to the length of the args array.
				//
				//   System.ArgumentOutOfRangeException:
				//     The length of the expanded string would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> AppendFormat(Riccsson::System::string* format, Riccsson::System::Array<object>* args)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string returned by processing a composite format string, which
				//     contains zero or more format items, to this instance. Each format item is
				//     replaced by the string representation of a corresponding argument in a parameter
				//     array using a specified format provider.
				//
				// Parameters:
				//   provider:
				//     An object that supplies culture-specific formatting information.
				//
				//   format:
				//     A composite format string (see Remarks).
				//
				//   args:
				//     An array of objects to format.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed. After
				//     the append operation, this instance contains any data that existed before
				//     the operation, suffixed by a copy of format where any format specification
				//     is replaced by the string representation of the corresponding object argument.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     format is null.
				//
				//   System.FormatException:
				//     format is invalid. -or-The index of a format item is less than 0 (zero),
				//     or greater than or equal to the length of the args array.
				//
				//   System.ArgumentOutOfRangeException:
				//     The length of the expanded string would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> AppendFormat(IFormatProvider* provider, Riccsson::System::string* format, Riccsson::System::Array<object>* args)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string returned by processing a composite format string, which
				//     contains zero or more format items, to this instance. Each format item is
				//     replaced by the string representation of either of two arguments.
				//
				// Parameters:
				//   format:
				//     A composite format string (see Remarks).
				//
				//   arg0:
				//     The first object to format.
				//
				//   arg1:
				//     The second object to format.
				//
				// Returns:
				//     A reference to this instance with format appended. Each format item in format
				//     is replaced by the string representation of the corresponding object argument.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     format is null.
				//
				//   System.FormatException:
				//     format is invalid.-or-The index of a format item is less than 0 (zero), or
				//     greater than or equal to 2.
				//
				//   System.ArgumentOutOfRangeException:
				//     The length of the expanded string would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> AppendFormat(Riccsson::System::string* format, Riccsson::System::object* arg0, Riccsson::System::object* arg1)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the string returned by processing a composite format string, which
				//     contains zero or more format items, to this instance. Each format item is
				//     replaced by the string representation of either of three arguments.
				//
				// Parameters:
				//   format:
				//     A composite format string (see Remarks).
				//
				//   arg0:
				//     The first object to format.
				//
				//   arg1:
				//     The second object to format.
				//
				//   arg2:
				//     The third object to format.
				//
				// Returns:
				//     A reference to this instance with format appended. Each format item in format
				//     is replaced by the string representation of the corresponding object argument.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     format is null.
				//
				//   System.FormatException:
				//     format is invalid.-or-The index of a format item is less than 0 (zero), or
				//     greater than or equal to 3.
				//
				//   System.ArgumentOutOfRangeException:
				//     The length of the expanded string would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> AppendFormat(Riccsson::System::string* format, Riccsson::System::object* arg0, Riccsson::System::object* arg1, Riccsson::System::object* arg2)
				{
					throw;
				}

				//
				// Summary:
				//     Appends the default line terminator to the end of the current System.Text.StringBuilder
				//     object.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				//[ComVisible(false)]
				public: GC_PTR<StringBuilder> AppendLine()
				{
					throw;
				}

				//
				// Summary:
				//     Appends a copy of the specified string followed by the default line terminator
				//     to the end of the current System.Text.StringBuilder object.
				//
				// Parameters:
				//   value:
				//     The string to append.
				//
				// Returns:
				//     A reference to this instance after the append operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				//[ComVisible(false)]
				public: GC_PTR<StringBuilder> AppendLine(Riccsson::System::string* value)
				{
					throw;
				}

				//
				// Summary:
				//     Removes all characters from the current System.Text.StringBuilder instance.
				//
				// Returns:
				//     An object whose System.Text.StringBuilder.Length is 0 (zero).
				public: GC_PTR<StringBuilder> Clear()
				{
					throw;
				}

				//
				// Summary:
				//     Copies the characters from a specified segment of this instance to a specified
				//     segment of a destination System.Char array.
				//
				// Parameters:
				//   sourceIndex:
				//     The starting position in this instance where characters will be copied from.
				//     The index is zero-based.
				//
				//   destination:
				//     The array where characters will be copied.
				//
				//   destinationIndex:
				//     The starting position in destination where characters will be copied. The
				//     index is zero-based.
				//
				//   count:
				//     The number of characters to be copied.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     destination is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     sourceIndex, destinationIndex, or count, is less than zero.-or-sourceIndex
				//     is greater than the length of this instance.
				//
				//   System.ArgumentException:
				//     sourceIndex + count is greater than the length of this instance.-or-destinationIndex
				//     + count is greater than the length of destination.
				//[ComVisible(false)]
				//[SecuritySafeCritical]
				public: void CopyTo(int sourceIndex, Riccsson::System::Array<char>* destination, int destinationIndex, int count)
				{
					throw;
				}

				//
				// Summary:
				//     Ensures that the capacity of this instance of System.Text.StringBuilder is
				//     at least the specified value.
				//
				// Parameters:
				//   capacity:
				//     The minimum capacity to ensure.
				//
				// Returns:
				//     The new capacity of this instance.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     capacity is less than zero.-or- Enlarging the value of this instance would
				//     exceed System.Text.StringBuilder.MaxCapacity.
				public: int EnsureCapacity(int capacity)
				{
					throw;
				}

				//
				// Summary:
				//     Returns a value indicating whether this instance is equal to a specified
				//     object.
				//
				// Parameters:
				//   sb:
				//     An object to compare with this instance, or null.
				//
				// Returns:
				//     true if this instance and sb have equal string, System.Text.StringBuilder.Capacity,
				//     and System.Text.StringBuilder.MaxCapacity values; otherwise, false.
				public: bool Equals(StringBuilder* sb)
				{
					throw;
				}

				//
				// Summary:
				//     Inserts the string representation of a Boolean value into this instance at
				//     the specified character position.
				//
				// Parameters:
				//   index:
				//     The position in this instance where insertion begins.
				//
				//   value:
				//     The value to insert.
				//
				// Returns:
				//     A reference to this instance after the insert operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     index is less than zero or greater than the length of this instance.
				//
				//   System.OutOfMemoryException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Insert(int index, bool value)
				{
					throw;
				}

				//
				// Summary:
				//     Inserts the string representation of a specified 8-bit unsigned integer into
				//     this instance at the specified character position.
				//
				// Parameters:
				//   index:
				//     The position in this instance where insertion begins.
				//
				//   value:
				//     The value to insert.
				//
				// Returns:
				//     A reference to this instance after the insert operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     index is less than zero or greater than the length of this instance.
				//
				//   System.OutOfMemoryException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Insert(int index, byte value)
				{
					throw;
				}

				//
				// Summary:
				//     Inserts the string representation of a specified Unicode character into this
				//     instance at the specified character position.
				//
				// Parameters:
				//   index:
				//     The position in this instance where insertion begins.
				//
				//   value:
				//     The value to insert.
				//
				// Returns:
				//     A reference to this instance after the insert operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     index is less than zero or greater than the length of this instance.-or-
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				//[SecuritySafeCritical]
				public: GC_PTR<StringBuilder> Insert(int index, char value)
				{
					throw;
				}

				//
				// Summary:
				//     Inserts the string representation of a specified array of Unicode characters
				//     into this instance at the specified character position.
				//
				// Parameters:
				//   index:
				//     The position in this instance where insertion begins.
				//
				//   value:
				//     The character array to insert.
				//
				// Returns:
				//     A reference to this instance after the insert operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     index is less than zero or greater than the length of this instance.-or-
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Insert(int index, Riccsson::System::Array<char>* value)
				{
					throw;
				}

				//
				// Summary:
				//     Inserts the string representation of a decimal number into this instance
				//     at the specified character position.
				//
				// Parameters:
				//   index:
				//     The position in this instance where insertion begins.
				//
				//   value:
				//     The value to insert.
				//
				// Returns:
				//     A reference to this instance after the insert operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     index is less than zero or greater than the length of this instance.
				//
				//   System.OutOfMemoryException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Insert(int index, decimal value)
				{
					throw;
				}

				//
				// Summary:
				//     Inserts the string representation of a double-precision floating-point number
				//     into this instance at the specified character position.
				//
				// Parameters:
				//   index:
				//     The position in this instance where insertion begins.
				//
				//   value:
				//     The value to insert.
				//
				// Returns:
				//     A reference to this instance after the insert operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     index is less than zero or greater than the length of this instance.
				//
				//   System.OutOfMemoryException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Insert(int index, double value)
				{
					throw;
				}

				//
				// Summary:
				//     Inserts the string representation of a single-precision floating point number
				//     into this instance at the specified character position.
				//
				// Parameters:
				//   index:
				//     The position in this instance where insertion begins.
				//
				//   value:
				//     The value to insert.
				//
				// Returns:
				//     A reference to this instance after the insert operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     index is less than zero or greater than the length of this instance.
				//
				//   System.OutOfMemoryException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Insert(int index, float value)
				{
					throw;
				}

				//
				// Summary:
				//     Inserts the string representation of a specified 32-bit signed integer into
				//     this instance at the specified character position.
				//
				// Parameters:
				//   index:
				//     The position in this instance where insertion begins.
				//
				//   value:
				//     The value to insert.
				//
				// Returns:
				//     A reference to this instance after the insert operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     index is less than zero or greater than the length of this instance.
				//
				//   System.OutOfMemoryException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Insert(int index, int value)
				{
					throw;
				}

				//
				// Summary:
				//     Inserts the string representation of a 64-bit signed integer into this instance
				//     at the specified character position.
				//
				// Parameters:
				//   index:
				//     The position in this instance where insertion begins.
				//
				//   value:
				//     The value to insert.
				//
				// Returns:
				//     A reference to this instance after the insert operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     index is less than zero or greater than the length of this instance.
				//
				//   System.OutOfMemoryException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Insert(int index, long value)
				{
					throw;
				}

				//
				// Summary:
				//     Inserts the string representation of an object into this instance at the
				//     specified character position.
				//
				// Parameters:
				//   index:
				//     The position in this instance where insertion begins.
				//
				//   value:
				//     The object to insert, or null.
				//
				// Returns:
				//     A reference to this instance after the insert operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     index is less than zero or greater than the length of this instance.
				//
				//   System.OutOfMemoryException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Insert(int index, Riccsson::System::object* value)
				{
					throw;
				}

				//
				// Summary:
				//     Inserts the string representation of a specified 8-bit signed integer into
				//     this instance at the specified character position.
				//
				// Parameters:
				//   index:
				//     The position in this instance where insertion begins.
				//
				//   value:
				//     The value to insert.
				//
				// Returns:
				//     A reference to this instance after the insert operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     index is less than zero or greater than the length of this instance.
				//
				//   System.OutOfMemoryException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				//[CLSCompliant(false)]
				public: GC_PTR<StringBuilder> Insert(int index, sbyte value)
				{
					throw;
				}

				//
				// Summary:
				//     Inserts the string representation of a specified 16-bit signed integer into
				//     this instance at the specified character position.
				//
				// Parameters:
				//   index:
				//     The position in this instance where insertion begins.
				//
				//   value:
				//     The value to insert.
				//
				// Returns:
				//     A reference to this instance after the insert operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     index is less than zero or greater than the length of this instance.
				//
				//   System.OutOfMemoryException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Insert(int index, short value)
				{
					throw;
				}

				//
				// Summary:
				//     Inserts a string into this instance at the specified character position.
				//
				// Parameters:
				//   index:
				//     The position in this instance where insertion begins.
				//
				//   value:
				//     The string to insert.
				//
				// Returns:
				//     A reference to this instance after the insert operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     index is less than zero or greater than the current length of this instance.
				//     -or-The current length of this System.Text.StringBuilder object plus the
				//     length of value exceeds System.Text.StringBuilder.MaxCapacity.
				//[SecuritySafeCritical]
				public: GC_PTR<StringBuilder> Insert(int index, Riccsson::System::string* value)
				{
					throw;
				}

				//
				// Summary:
				//     Inserts the string representation of a 32-bit unsigned integer into this
				//     instance at the specified character position.
				//
				// Parameters:
				//   index:
				//     The position in this instance where insertion begins.
				//
				//   value:
				//     The value to insert.
				//
				// Returns:
				//     A reference to this instance after the insert operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     index is less than zero or greater than the length of this instance.
				//
				//   System.OutOfMemoryException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				//[CLSCompliant(false)]
				public: GC_PTR<StringBuilder> Insert(int index, uint value)
				{
					throw;
				}

				//
				// Summary:
				//     Inserts the string representation of a 64-bit unsigned integer into this
				//     instance at the specified character position.
				//
				// Parameters:
				//   index:
				//     The position in this instance where insertion begins.
				//
				//   value:
				//     The value to insert.
				//
				// Returns:
				//     A reference to this instance after the insert operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     index is less than zero or greater than the length of this instance.
				//
				//   System.OutOfMemoryException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				//[CLSCompliant(false)]
				public: GC_PTR<StringBuilder> Insert(int index, ulong value)
				{
					throw;
				}

				//
				// Summary:
				//     Inserts the string representation of a 16-bit unsigned integer into this
				//     instance at the specified character position.
				//
				// Parameters:
				//   index:
				//     The position in this instance where insertion begins.
				//
				//   value:
				//     The value to insert.
				//
				// Returns:
				//     A reference to this instance after the insert operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     index is less than zero or greater than the length of this instance.
				//
				//   System.OutOfMemoryException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				//[CLSCompliant(false)]
				public: GC_PTR<StringBuilder> Insert(int index, ushort value)
				{
					throw;
				}

				//
				// Summary:
				//     Inserts one or more copies of a specified string into this instance at the
				//     specified character position.
				//
				// Parameters:
				//   index:
				//     The position in this instance where insertion begins.
				//
				//   value:
				//     The string to insert.
				//
				//   count:
				//     The number of times to insert value.
				//
				// Returns:
				//     A reference to this instance after insertion has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     index is less than zero or greater than the current length of this instance.-or-
				//     count is less than zero.
				//
				//   System.OutOfMemoryException:
				//     The current length of this System.Text.StringBuilder object plus the length
				//     of value times count exceeds System.Text.StringBuilder.MaxCapacity.
				//[SecuritySafeCritical]
				public: GC_PTR<StringBuilder> Insert(int index, Riccsson::System::string* value, int count)
				{
					throw;
				}

				//
				// Summary:
				//     Inserts the string representation of a specified subarray of Unicode characters
				//     into this instance at the specified character position.
				//
				// Parameters:
				//   index:
				//     The position in this instance where insertion begins.
				//
				//   value:
				//     A character array.
				//
				//   startIndex:
				//     The starting index within value.
				//
				//   charCount:
				//     The number of characters to insert.
				//
				// Returns:
				//     A reference to this instance after the insert operation has completed.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     value is null, and startIndex and charCount are not zero.
				//
				//   System.ArgumentOutOfRangeException:
				//     index, startIndex, or charCount is less than zero.-or- index is greater than
				//     the length of this instance.-or- startIndex plus charCount is not a position
				//     within value.-or- Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				//[SecuritySafeCritical]
				public: GC_PTR<StringBuilder> Insert(int index, Riccsson::System::Array<char>* value, int startIndex, int charCount)
				{
					throw;
				}

				//
				// Summary:
				//     Removes the specified range of characters from this instance.
				//
				// Parameters:
				//   startIndex:
				//     The zero-based position in this instance where removal begins.
				//
				//   length:
				//     The number of characters to remove.
				//
				// Returns:
				//     A reference to this instance after the excise operation has completed.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     If startIndex or length is less than zero, or startIndex + length is greater
				//     than the length of this instance.
				public: GC_PTR<StringBuilder> Remove(int startIndex, int length)
				{
					throw;
				}

				//
				// Summary:
				//     Replaces all occurrences of a specified character in this instance with another
				//     specified character.
				//
				// Parameters:
				//   oldChar:
				//     The character to replace.
				//
				//   newChar:
				//     The character that replaces oldChar.
				//
				// Returns:
				//     A reference to this instance with oldChar replaced by newChar.
				public: GC_PTR<StringBuilder> Replace(char oldChar, char newChar)
				{
					throw;
				}

				//
				// Summary:
				//     Replaces all occurrences of a specified string in this instance with another
				//     specified string.
				//
				// Parameters:
				//   oldValue:
				//     The string to replace.
				//
				//   newValue:
				//     The string that replaces oldValue, or null.
				//
				// Returns:
				//     A reference to this instance with all instances of oldValue replaced by newValue.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     oldValue is null.
				//
				//   System.ArgumentException:
				//     The length of oldValue is zero.
				//
				//   System.ArgumentOutOfRangeException:
				//     Enlarging the value of this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Replace(Riccsson::System::string* oldValue, Riccsson::System::string* newValue)
				{
					throw;
				}

				//
				// Summary:
				//     Replaces, within a substring of this instance, all occurrences of a specified
				//     character with another specified character.
				//
				// Parameters:
				//   oldChar:
				//     The character to replace.
				//
				//   newChar:
				//     The character that replaces oldChar.
				//
				//   startIndex:
				//     The position in this instance where the substring begins.
				//
				//   count:
				//     The length of the substring.
				//
				// Returns:
				//     A reference to this instance with oldChar replaced by newChar in the range
				//     from startIndex to startIndex + count -1.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     startIndex + count is greater than the length of the value of this instance.-or-
				//     startIndex or count is less than zero.
				public: GC_PTR<StringBuilder> Replace(char oldChar, char newChar, int startIndex, int count)
				{
					throw;
				}

				//
				// Summary:
				//     Replaces, within a substring of this instance, all occurrences of a specified
				//     string with another specified string.
				//
				// Parameters:
				//   oldValue:
				//     The string to replace.
				//
				//   newValue:
				//     The string that replaces oldValue, or null.
				//
				//   startIndex:
				//     The position in this instance where the substring begins.
				//
				//   count:
				//     The length of the substring.
				//
				// Returns:
				//     A reference to this instance with all instances of oldValue replaced by newValue
				//     in the range from startIndex to startIndex + count - 1.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     oldValue is null.
				//
				//   System.ArgumentException:
				//     The length of oldValue is zero.
				//
				//   System.ArgumentOutOfRangeException:
				//     startIndex or count is less than zero.-or- startIndex plus count indicates
				//     a character position not within this instance.-or- Enlarging the value of
				//     this instance would exceed System.Text.StringBuilder.MaxCapacity.
				public: GC_PTR<StringBuilder> Replace(Riccsson::System::string* oldValue, Riccsson::System::string* newValue, int startIndex, int count)
				{
					throw;
				}

				//
				// Summary:
				//     Converts the value of this instance to a System.String.
				//
				// Returns:
				//     A string whose value is the same as this instance.
				//[SecuritySafeCritical]
				public: override GC_PTR<Riccsson::System::string> ToString()
				{
					throw;
				}

				//
				// Summary:
				//     Converts the value of a substring of this instance to a System.String.
				//
				// Parameters:
				//   startIndex:
				//     The starting position of the substring in this instance.
				//
				//   length:
				//     The length of the substring.
				//
				// Returns:
				//     A string whose value is the same as the specified substring of this instance.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     startIndex or length is less than zero.-or- The sum of startIndex and length
				//     is greater than the length of the current instance.
				//[SecuritySafeCritical]
				public: GC_PTR<Riccsson::System::string> ToString(int startIndex, int length)
				{
					throw;
				}

			};
		}
	}
}

#endif